matlab gpu-array Search Results


gpuarray  (MathWorks Inc)
90
MathWorks Inc gpuarray
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpuarray, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpuarray/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpuarray - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
gpuarrays  (MathWorks Inc)
90
MathWorks Inc gpuarrays
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpuarrays, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpuarrays/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpuarrays - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
gpuarray matlab function  (MathWorks Inc)
90
MathWorks Inc gpuarray matlab function
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpuarray Matlab Function, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpuarray matlab function/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpuarray matlab function - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
matlab gpu-array  (MathWorks Inc)
90
MathWorks Inc matlab gpu-array
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Matlab Gpu Array, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/matlab gpu-array/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
matlab gpu-array - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
gpuarray tools  (MathWorks Inc)
90
MathWorks Inc gpuarray tools
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpuarray Tools, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpuarray tools/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpuarray tools - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
gpuarray functionality  (MathWorks Inc)
90
MathWorks Inc gpuarray functionality
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpuarray Functionality, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpuarray functionality/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpuarray functionality - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
2016a  (MathWorks Inc)
90
MathWorks Inc 2016a
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
2016a, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/2016a/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
2016a - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
int16 matlab gpuarray  (MathWorks Inc)
90
MathWorks Inc int16 matlab gpuarray
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Int16 Matlab Gpuarray, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/int16 matlab gpuarray/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
int16 matlab gpuarray - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier
gpu arrays  (MathWorks Inc)
90
MathWorks Inc gpu arrays
Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A <t>(gpuArray,</t> green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .
Gpu Arrays, supplied by MathWorks Inc, used in various techniques. Bioz Stars score: 90/100, based on 1 PubMed citations. ZERO BIAS - scores, article reviews, protocol conditions and more
https://www.bioz.com/result/gpu arrays/product/MathWorks Inc
Average 90 stars, based on 1 article reviews
gpu arrays - by Bioz Stars, 2026-04
90/100 stars
  Buy from Supplier

Image Search Results


Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A (gpuArray, green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .

Journal: bioRxiv

Article Title: Fast estimation of L1-regularized linear models in the mass-univariate setting

doi: 10.1101/2020.01.16.909234

Figure Lengend Snippet: Benchmark results for the three lasso functions lasso_mex , lasso_mexcuda and lasso_gpu . A: Benchmark for an overparameterized setting with n = 300 time points and p = 5000 predictors, corresponding for example to an encoding model with a large feature space. The lasso_mex function required considerably less running time for whole-brain estimates than the standard lasso function (Matlab, orange) on a single CPU core (C++, light blue). Distributing computations across multiple CPU cores further reduced the running time of the lasso_mex function (OpenMP, dark blue). The lasso_mexcuda function, which runs the ADMM algorithm on a GPU using the cuBLAS library, further accelerated the estimation procedure (cuBLAS, green). The lasso_gpu function, which runs the ADMM algorithm on the GPU using the Parallel Computing Toolbox, provided the highest speed-up factor for benchmark A (gpuArray, green/orange). B: Benchmark for a well-defined setting with fewer predictors than time points ( n = 300, p = 200), corresponding for example to a single-trial or FIR model. Again, on a single CPU core, the lasso_mex function fitted L1-regularized models more efficiently than the standard lasso function. Further speed-up could be achieved by distributing computations across multiple CPU cores. The GPU-based implementations ( lasso_mexcuda , lasso_gpu ) performed not as fast as the multicore CPU version on this benchmark, as the GPU was not fully occupied in this small-scale setting. Unregularized (OLS, yellow) or L2-regularized (ridge, gray) model estimation using closed-form solutions remains faster than accelerated L1-regularization. Absolute computation times are given in .

Article Snippet: The second version ( lasso_gpu ) is implemented directly in Matlab using gpuArray and thus depends on the Parallel Computing Toolbox.

Techniques: